
from IPython.display import Image
import matplotlib.image as mpimg
import matplotlib.pyplot as plt

img = mpimg.imread('netflix1.png')
plt.figure(figsize=(14, 10))
plt.imshow(img)
plt.show()
img = mpimg.imread('netflix2.png')
plt.figure(figsize=(14, 10))
plt.imshow(img)
plt.show()
img = mpimg.imread('netflix3.png')
plt.figure(figsize=(14, 10))
plt.imshow(img)
plt.show()


import numpy as np
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
import matplotlib.cm as cm
from wordcloud import WordCloud, STOPWORDS
import itertools
from textblob import TextBlob


df = pd.read_csv("./netflix_titles.csv")
df2 = pd.read_csv("./imdb_top_1000.csv")
pd.set_option('display.max_columns', None)


df.isnull().sum()

show_id            0
type               0
title              0
director        2634
cast             825
country          831
date_added        10
release_year       0
rating             4
duration           3
listed_in          0
description        0
dtype: int64


df["country"].fillna("MISSING", inplace=True)
df["duration"].fillna("0 min", inplace=True)
df["director"].fillna("Unknown", inplace=True)
df["cast"].fillna("Unknown", inplace=True)
df["date_added"].fillna("Unknown", inplace=True)
df["rating"].fillna("Unknown", inplace=True)
df["duration"].fillna("Unknown", inplace=True)
df.head(n=3)

C:\Users\User\AppData\Local\Temp/ipykernel_14984/3613727334.py:1: FutureWarning: A value is trying to be set on a copy of a DataFrame or Series through chained assignment using an inplace method.
The behavior will change in pandas 3.0. This inplace method will never work because the intermediate object on which we are setting values always behaves as a copy.

For example, when doing 'df[col].method(value, inplace=True)', try using 'df.method({col: value}, inplace=True)' or df[col] = df[col].method(value) instead, to perform the operation inplace on the original object.


  df["country"].fillna("MISSING", inplace=True)
C:\Users\User\AppData\Local\Temp/ipykernel_14984/3613727334.py:2: FutureWarning: A value is trying to be set on a copy of a DataFrame or Series through chained assignment using an inplace method.
The behavior will change in pandas 3.0. This inplace method will never work because the intermediate object on which we are setting values always behaves as a copy.

For example, when doing 'df[col].method(value, inplace=True)', try using 'df.method({col: value}, inplace=True)' or df[col] = df[col].method(value) instead, to perform the operation inplace on the original object.


  df["duration"].fillna("0 min", inplace=True)
C:\Users\User\AppData\Local\Temp/ipykernel_14984/3613727334.py:3: FutureWarning: A value is trying to be set on a copy of a DataFrame or Series through chained assignment using an inplace method.
The behavior will change in pandas 3.0. This inplace method will never work because the intermediate object on which we are setting values always behaves as a copy.

For example, when doing 'df[col].method(value, inplace=True)', try using 'df.method({col: value}, inplace=True)' or df[col] = df[col].method(value) instead, to perform the operation inplace on the original object.


  df["director"].fillna("Unknown", inplace=True)
C:\Users\User\AppData\Local\Temp/ipykernel_14984/3613727334.py:4: FutureWarning: A value is trying to be set on a copy of a DataFrame or Series through chained assignment using an inplace method.
The behavior will change in pandas 3.0. This inplace method will never work because the intermediate object on which we are setting values always behaves as a copy.

For example, when doing 'df[col].method(value, inplace=True)', try using 'df.method({col: value}, inplace=True)' or df[col] = df[col].method(value) instead, to perform the operation inplace on the original object.


  df["cast"].fillna("Unknown", inplace=True)
C:\Users\User\AppData\Local\Temp/ipykernel_14984/3613727334.py:5: FutureWarning: A value is trying to be set on a copy of a DataFrame or Series through chained assignment using an inplace method.
The behavior will change in pandas 3.0. This inplace method will never work because the intermediate object on which we are setting values always behaves as a copy.

For example, when doing 'df[col].method(value, inplace=True)', try using 'df.method({col: value}, inplace=True)' or df[col] = df[col].method(value) instead, to perform the operation inplace on the original object.


  df["date_added"].fillna("Unknown", inplace=True)
C:\Users\User\AppData\Local\Temp/ipykernel_14984/3613727334.py:6: FutureWarning: A value is trying to be set on a copy of a DataFrame or Series through chained assignment using an inplace method.
The behavior will change in pandas 3.0. This inplace method will never work because the intermediate object on which we are setting values always behaves as a copy.

For example, when doing 'df[col].method(value, inplace=True)', try using 'df.method({col: value}, inplace=True)' or df[col] = df[col].method(value) instead, to perform the operation inplace on the original object.


  df["rating"].fillna("Unknown", inplace=True)


df.describe()


df.shape

(8807, 12)


df.columns

Index(['show_id', 'type', 'title', 'director', 'cast', 'country', 'date_added',
       'release_year', 'rating', 'duration', 'listed_in', 'description'],
      dtype='object')


df.count()

show_id         8807
type            8807
title           8807
director        8807
cast            8807
country         8807
date_added      8807
release_year    8807
rating          8807
duration        8807
listed_in       8807
description     8807
dtype: int64


df.nunique()

show_id         8807
type               2
title           8807
director        4529
cast            7693
country          749
date_added      1768
release_year      74
rating            18
duration         221
listed_in        514
description     8775
dtype: int64


print(f" dtype - show_id: {df.show_id.dtype}")
print(f" dtype - type: {df.type.dtype}")
print(f" dtype - title: {df.title.dtype}")
print(f" dtype - director: {df.director.dtype}")
print(f" dtype - cast: {df.cast.dtype}")
print(f" dtype - country: {df.country.dtype}")
print(f" dtype - date_added: {df.date_added.dtype}")
print(f" dtype - release_year: {df.release_year.dtype}")
print(f" dtype - rating: {df.rating.dtype}")
print(f" dtype - duration: {df.duration.dtype}")
print(f" dtype - listed_in: {df.listed_in.dtype}")
print(f" dtype - description: {df.description.dtype}")

 dtype - show_id: object
 dtype - type: object
 dtype - title: object
 dtype - director: object
 dtype - cast: object
 dtype - country: object
 dtype - date_added: object
 dtype - release_year: int64
 dtype - rating: object
 dtype - duration: object
 dtype - listed_in: object
 dtype - description: object


df.dropna(axis="index", how="all")


# df["duration"].unique()


l_num_dur=list() #creates a new list
l_seas_min=list() #creates another new list
for i in df["duration"]: #loop for duration column
    num_dur=int(i.split()[0]) #to get the integer value
    w_dur=i.split()[1] #to get the word Seasons/min
    l_num_dur.append(num_dur) #will add the numerical value of duration
    l_seas_min.append(w_dur) #will add either Seasons or min
df["Number duration"]=l_num_dur #puts the values in the list
df["Season/min"]=l_seas_min #puts the values in the list
df.head(n=3) #prints the dataframe


df["rating"].unique()

array(['PG-13', 'TV-MA', 'PG', 'TV-14', 'TV-PG', 'TV-Y', 'TV-Y7', 'R',
       'TV-G', 'G', 'NC-17', '74 min', '84 min', '66 min', 'NR',
       'Unknown', 'TV-Y7-FV', 'UR'], dtype=object)


print(df.loc[df["rating"]=="74 min", "duration"])
print(df.loc[df["rating"]=="84 min", "duration"])
print(df.loc[df["rating"]=="66 min", "duration"])
#There were 3 Nan values in the duration column, and the original values were put in ratings column

5541    0 min
Name: duration, dtype: object
5794    0 min
Name: duration, dtype: object
5813    0 min
Name: duration, dtype: object


df.loc[df["rating"]=="74 min", "duration"]="74 min"
df.loc[df["rating"]=="84 min", "duration"]="84 min"
df.loc[df["rating"]=="66 min", "duration"]="66 min"
df.loc[df["rating"]=="74 min", "rating"]="Unknown"
df.loc[df["rating"]=="84 min", "rating"]="Unknown"
df.loc[df["rating"]=="66 min", "rating"]="Unknown"


print(df["type"].unique()) #here we see that there are only two types: Movie and TV show
df_movies = df[df["type"] == "Movie"]
df_series = df[df["type"] == "TV Show"]

['Movie' 'TV Show']


df_movies.value_counts()
n_of_movies_and_tv_series = df["title"].nunique()
n_of_movies =  df_movies["title"].count()
n_of_shows = df_series["title"].count()
print(f"There are {n_of_movies} movies and {n_of_shows} TV shows in our dataset")
#that means that netflix produced more movies than TV shows
n_of_movies_and_tv_series

There are 6131 movies and 2676 TV shows in our dataset

8807


percentage_movies = (n_of_movies / n_of_movies_and_tv_series) * 100
percentage_tvshows =  (n_of_shows / n_of_movies_and_tv_series) * 100

labels = ['Movies', 'TV Shows']
values = [percentage_movies, percentage_tvshows]

colors_pie = ['#E50914', '#8C8C8C', '#221F1F']

plt.figure(figsize=(8,8))
plt.pie(values, colors = colors_pie, autopct='%1.1f%%', textprops={'fontsize': 14})
plt.title('Movies and TV Shows')
plt.legend(loc='upper right', labels=labels)
plt.show()


count_dict = {} #creates an empty dictionary

for year in df["release_year"]: #iterates over the dictionary
    if year in count_dict: #checks whether that year already exists in dictionary as a key
        count_dict[year] += 1 #if yes, adds 1 to its value
    else:
        count_dict[year] = 1 #if no, adds it to the dictionary as a key

max_n = max(count_dict.values()) #finds the maximum number of movies  
min_n = min(count_dict.values()) #finds the minimum number of movies
list_of_min = []
list_of_max = []
for i in count_dict.keys():
    if count_dict[i] == max_n:
        list_of_max.append(i) #iterating over dictionary keys, finds what keys have the value = to maximum number of movies, and add to the list
        
    if count_dict[i] == min_n:
        list_of_min.append(i) #the same with minimum number of movies
        
print(f"{list_of_max} is/are the year(s) when the highest number of film/series available on Netflix were produced.")
print(f"{list_of_min} is/are the year(s) when the lowest number of film/series available on Netflix were produced.")

[2018] is/are the year(s) when the highest number of film/series available on Netflix were produced.
[1961, 1959, 1925, 1966, 1947] is/are the year(s) when the lowest number of film/series available on Netflix were produced.


keys = list(count_dict.keys()) #creates a list from dictionary keys
keys.sort() #sorts the list to avoid the mess in the graph

value_counts_2 = {} #creates an empty dictionary
for i in keys:
    value_counts_2[i] = count_dict[i] 

keys_2 = list(value_counts_2.keys())
values_2 = list(value_counts_2.values())

plt.figure(figsize=(12,10))
plt.plot(keys_2, values_2, color="red")
plt.xlabel("Years")
plt.xlim(1997,2023) #since the netflix was founded only in 1997
plt.ylabel("Number of movies")
plt.title("Number of produced movies over years")
plt.show()


rating_list = list(df["rating"].unique()) # creates a list of all unique movie ratings in the dataset

rating_list.remove("Unknown") # removes the "Unknown" rating from the list

rating_count_dict = {} # creates an empty dictionary to store the counts of each rating

for rating in df["rating"]: # Iterates over each movie in the dataset
    # if the rating is already in the dictionary, increment its count
    if rating in rating_count_dict:
        rating_count_dict[rating] += 1
    # if the rating is not "Unknown" and not already in the dictionary, add it with a count of 1
    elif rating != "Unknown":
        rating_count_dict[rating] = 1

keys_3 = rating_count_dict.keys() #gets the keys(ratings)
values_3 = rating_count_dict.values() #gets the values(counts)

plt.figure(figsize=(12,8))# creates a figure with a size of 12 x 8 inches
plt.bar(keys_3, values_3, color="darkred", ec="black")
#creates a bar chart with the ratings on the x-axis, counts on the y-axis, dark red bars, and black edges
plt.xticks(rotation=45) #rotates the x-axis labels by 45 degrees for readability
plt.ylabel("Number of movies") #sets y-axis label
plt.xlabel("Rating") #sets x-axis label
plt.title("Motion Picture Association film rating system") #sets the title
plt.show() #displays the chart


title_text = ' '.join(df['title'].dropna())
wordcloud = WordCloud(stopwords=STOPWORDS, background_color='white', colormap="Reds", width=800, height=400).generate(title_text)
plt.figure(figsize=(12,10))
plt.imshow(wordcloud, interpolation='bilinear')
plt.axis('off')
plt.show()


director_counts = df[df["director"]!="Unknown"]['director'].value_counts()
popular_directors=director_counts[director_counts>10]

colormap=cm.ScalarMappable(cmap=cm.Reds) # create a colormap
colormap.set_clim(popular_directors.min(), popular_directors.max()) # set the limits for the colormap
#color=colormap.to_rgba(popular_directors)

plt.figure(figsize=(12,8)) # creates a figure with a size of 12 x 8 inches
popular_directors.plot(kind='bar', color=colormap.to_rgba(popular_directors), ec="black" ) # plot a bar chart with the colormap
plt.title('Number of Movies Directed by Each Director (top 10 directors)') # set the title
plt.xlabel('Director') # set the x-axis label
plt.ylabel('Number of Movies') # set the y-axis label
plt.xticks(rotation=45, fontsize = 12) # rotate the x-axis labels
plt.show() # display the plot


duration_of_movies=df[df["Season/min"]=="min"]["Number duration"]
plt.figure(figsize=(12,8))
plt.hist(duration_of_movies, bins=25, color="red", ec="black")
plt.title("Duration Distribution")
plt.xlabel("Movie Duration")
plt.ylabel("Number of movies")
plt.show()


duration_of_tvshows=df[df["Season/min"]=="Seasons"]["Number duration"]
plt.figure(figsize=(12,8))
plt.hist(duration_of_tvshows, bins=10, color="black", ec="red")
plt.title("Duration Distribution")
plt.xlabel("TV Show Duration")
plt.ylabel("Number of TV Shows")
plt.show()


df[df["Season/min"]=="min"].groupby(df["release_year"])["Number duration"].agg(["mean", "max", "min"])
mean_durations=df[df["Season/min"]=="min"].groupby(df["release_year"])["Number duration"].mean()

plt.figure(figsize=(12,8))
plt.bar(mean_durations.index, mean_durations.values, color="white", edgecolor="red")
plt.title('Average movie duration for each year')
plt.xlabel('year')
plt.ylabel('average movie duration')
plt.show()


for index,row in df.iterrows():
    
    d=row['description']
    d_blob=TextBlob(d)
    d_polarity=d_blob.sentiment.polarity
    
    if d_polarity<0:
        d_sentiment='Negative'
    elif d_polarity>0:
        d_sentiment='Positive'
    else:
        d_sentiment='Neutral'
    df.loc[[index,2],'Description_Sentiment']=d_sentiment


d_sentiment_counts=df.groupby(["release_year", "Description_Sentiment"]).size().unstack()

d_sentiment_counts = d_sentiment_counts.loc[2000:]

colors = {'Negative': 'red', 'Neutral': 'black', 'Positive': 'grey'}

plt.figure(figsize=(30,30))
d_sentiment_counts.plot(kind='bar', stacked=True, color=[colors[c] for c in d_sentiment_counts.columns])

plt.xlabel('Year')
plt.ylabel('Number of movies')
plt.title('Sentiment Content of Netflix')
plt.show()

<Figure size 2160x2160 with 0 Axes>


countries_list = [] #creates a new list for countries
for i in df["country"]: #iterates over the values in column "Countries"
    if "," in i: #finds the rows which have several values for "Countries", separated by commas
        a=str(i).split(sep = ",") #creates a new variable a and assigns to it splitted values in form of list
#        list_a = list(a)  will delete this part
        for b in a: #iterates over list a with separated countries
            countries_list.append(b) #appends the countries to the initial list
    else:
        countries_list.append(i) #if there are no commas, it means that only one country is mentioned, so we append that country to the list
    
new_countries_list =[x for x in countries_list if x != "MISSING" and x != ""] #deletes all the "Missing" values from countries_list and assigns to a new list
new_countries_list_2 = [x.strip() for x in new_countries_list] #since some of them come with unnecessary spaces, strip deletes those spaces

from collections import Counter

country_counts = Counter(new_countries_list_2) #creates a Counter object and assigns it to country_counts
country_counts_dict = dict(country_counts) #converts the Counter object country_counts to a regular dictionary country_counts_dict.
countries = country_counts_dict.keys() #creates a new variable called countries, which contains a list of all the unique country names in new_countries_list_2.
n_of_movies_countries = country_counts_dict.values() #creates a new variable called n_of_movies_countries, which contains a list of the number of movies produced in each country.


import json
import folium

geo_json_data = json.load(open('countries.geojson')) #loads the countries.geojson file, which contains geographic data for all the countries in the world
df_2 = pd.DataFrame({'Country': list(countries), 'Movie Count': list(n_of_movies_countries)}) #creates a new pandas DataFrame called df_2
#Country column contains a list of all the unique country names in new_countries_list_2
#Movie Count column contains a list of the number of movies produced in each country.
map = folium.Map(location=[37.0902, -95.7129], zoom_start=2) #creates a new folium Map object, which will be used to display the choropleth map.
#"Location" sets the center of map to be United States
#"Zoom start" sets the zoom level of the map 
folium.Choropleth(
    geo_data= geo_json_data,
    name='choropleth',
    data=df_2,
    columns=['Country', 'Movie Count'],
    key_on='properties.ADMIN', #specifies the key in the geo_json_data that matches the country names in df_2
    fill_color='YlGn',
    fill_opacity=0.7,
    line_opacity=0.2,
    legend_name='Number of Movies', #sets the label
    highlight=True
    
).add_to(map)

map


df2.isnull().sum()

Poster_Link        0
Series_Title       0
Released_Year      0
Certificate      101
Runtime            0
Genre              0
IMDB_Rating        0
Overview           0
Meta_score       157
Director           0
Star1              0
Star2              0
Star3              0
Star4              0
No_of_Votes        0
Gross            169
dtype: int64


df2.describe()


df2.shape

(1000, 16)


df2.columns

Index(['Poster_Link', 'Series_Title', 'Released_Year', 'Certificate',
       'Runtime', 'Genre', 'IMDB_Rating', 'Overview', 'Meta_score', 'Director',
       'Star1', 'Star2', 'Star3', 'Star4', 'No_of_Votes', 'Gross'],
      dtype='object')


df2.count()

Poster_Link      1000
Series_Title     1000
Released_Year    1000
Certificate       899
Runtime          1000
Genre            1000
IMDB_Rating      1000
Overview         1000
Meta_score        843
Director         1000
Star1            1000
Star2            1000
Star3            1000
Star4            1000
No_of_Votes      1000
Gross             831
dtype: int64


df2.nunique()

Poster_Link      1000
Series_Title      999
Released_Year     100
Certificate        16
Runtime           140
Genre             202
IMDB_Rating        17
Overview         1000
Meta_score         63
Director          548
Star1             660
Star2             841
Star3             891
Star4             939
No_of_Votes       999
Gross             823
dtype: int64


df2.columns=['Poster_Link', 'title', 'Released_Year', 'Certificate',
       'Runtime', 'Genre', 'IMDB_Rating', 'Overview', 'Meta_score', 'Director',
       'Star1', 'Star2', 'Star3', 'Star4', 'No_of_Votes', 'Gross']


df2.loc[:, 'Released_Year'] = pd.to_numeric(df2['Released_Year'], errors='coerce').astype('Int64')


merged_df = pd.merge(df, df2, on='title')


sxal_director=merged_df[merged_df["director"]!=merged_df["Director"]]
sxaltaridirectorov=sxal_director[sxal_director["release_year"]!=sxal_director["Released_Year"]]
sxaltaridirectorov[["director", "Director", "release_year", "Released_Year"]]
netflix_top_imdb=merged_df.drop(sxaltaridirectorov.index)


meta_score=netflix_top_imdb["Meta_score"]
imdb_rating=netflix_top_imdb["IMDB_Rating"]

corr_coeff = round(meta_score.corr(imdb_rating), 2)
print(f"Correlation coefficient: {corr_coeff}")
print("There is a weak positive correlation between user and critic ratings.")

plt.figure(figsize=(12,8))
sns.regplot(x=meta_score, y=imdb_rating, scatter=True, color='black', line_kws={"color": "red"})
plt.xlabel("Meta Score")
plt.ylabel("IMDB Rating")
plt.title("Correlation between user ratings and critic reviews")
plt.show()

Correlation coefficient: 0.29
There is a weak positive correlation between user and critic ratings.


no_of_votes=netflix_top_imdb["No_of_Votes"]
imdb_rating=netflix_top_imdb["IMDB_Rating"]

corr_coeff = round(no_of_votes.corr(imdb_rating), 2)
print(f"Correlation coefficient: {corr_coeff}")
print("There is a weak positive correlation between user ratings and number of their votes.")

plt.figure(figsize=(12,8))
sns.regplot(x=no_of_votes, y=imdb_rating, scatter=True, color='red', line_kws={"color": "black"})
plt.xlabel("Number of votes")
plt.ylabel("IMDB Rating")
plt.title("Correlation between user ratings and number of votes")
plt.show()

Correlation coefficient: 0.59
There is a weak positive correlation between user ratings and number of their votes.


popular_genres = []
for index, row in netflix_top_imdb.iterrows():
    popular_genres.extend(row['Genre'].split(', '))


genres_count = pd.Series(popular_genres).value_counts()

plt.figure(figsize=(12,8))
plt.bar(genres_count.index, genres_count.values, color="red", ec="black", linewidth=2)
plt.xticks(rotation=45)
plt.xlabel('genre')
plt.ylabel('Number of movies')
plt.title('Top genres in movies with top 1000 imdb ratings(poxela petq anuny)')
plt.show()


stars=netflix_top_imdb[["Star1", "Star2", "Star3", "Star4"]]
actors = []
for index, row in stars.iterrows():
    actors.append(row["Star1"])
    actors.append(row["Star2"])
    actors.append(row["Star3"])
    actors.append(row["Star4"])


actors_count = pd.Series(actors).value_counts()
top_actor_count = actors_count[:10]

plt.figure(figsize=(12,8))
plt.barh(top_actor_count.index, top_actor_count.values, color="black", ec="red", linewidth=2)
plt.xlabel("Number of movies")
plt.ylabel("Actors")
plt.yticks(fontsize=12)
plt.title('Top 10 Actors whose movies are in top 1000 imdb ratings(poxela petq anuny)')
plt.show()


actors_array=np.array(actors)
actors_array=np.char.replace(actors_array, " ", "")


plt.figure(figsize=(12,8))
wordcloud = WordCloud(background_color='black', colormap="Reds", width=800, height=400).generate(' '.join(actors_array))
plt.imshow(wordcloud, interpolation='bilinear')
plt.axis('off')
plt.show()


#Colloboration graph FOR TOP 10 DIRECTORS
import networkx as nx

#finding top 10 directors
top_directors2=netflix_top_imdb.groupby("Director").size()
top_directors2=top_directors2.sort_values(ascending=False) #to make it descending
top_directors2=top_directors2[0:10].index #top10
top_directors2=top_directors2.tolist() 

collab=netflix_top_imdb[netflix_top_imdb["Director"].isin(top_directors2)]
collab=collab[["Director", "Star1", "Star2", "Star3", "Star4"]]
top_actors2 = collab[['Star1', 'Star2', 'Star3', 'Star4']].values.flatten().tolist()


G = nx.Graph()
G.add_nodes_from(top_directors2, type='director')
G.add_nodes_from(top_actors2, type='actor')

for index, row in collab.iterrows():
    director = row['Director']
    for actor in row[['Star1', 'Star2', 'Star3', 'Star4']]:
        G.add_edge(director, actor)

plt.figure(figsize=(30,30))

pos = nx.spring_layout(G)
nx.draw_networkx_nodes(G, pos, nodelist=top_directors2, node_size=1000, node_color='red', alpha=0.8)
nx.draw_networkx_nodes(G, pos, nodelist=top_actors2, node_size=500, node_color='pink', alpha=0.8)
nx.draw_networkx_edges(G, pos, width=1, alpha=0.3)
nx.draw_networkx_labels(G, pos, font_size=10)
plt.axis('off')
plt.show()


groups=(netflix_top_imdb.sort_values('IMDB_Rating', ascending=False)).groupby(["IMDB_Rating"])
for rating, group in groups:
    print(f"Movies with IMDB rating {rating}:")
    for i, row in group.iterrows():
        print(f"{row['title']}) ")
    print("\n")

Movies with IMDB rating (7.6,):
The Naked Gun: From the Files of Police Squad!) 
Blow) 
American Psycho) 
End of Watch) 
Seven Pounds) 
Philomena) 
Fear and Loathing in Las Vegas) 
Hell or High Water) 
The Florida Project) 
Stardust) 
50/50) 
Sherlock Holmes) 
Zombieland) 


Movies with IMDB rating (7.7,):
I Am Sam) 
The Social Network) 
Flipped) 
Wind River) 
The Machinist) 
Silver Linings Playbook) 
Zodiac) 
Training Day) 
Rebel Without a Cause) 
God's Own Country) 
Donnie Brasco) 
Crash) 
Coraline) 
Enter the Dragon) 
Ex Machina) 
Black Hawk Down) 
Billy Elliot) 
Beasts of No Nation) 
As Good as It Gets) 
Philadelphia) 
Primal Fear) 
The Theory of Everything) 


Movies with IMDB rating (7.8,):
Udta Punjab) 
What's Eating Gilbert Grape) 
My Fair Lady) 
The Trial of the Chicago 7) 
Willy Wonka & the Chocolate Factory) 
Bonnie and Clyde) 
How to Train Your Dragon 2) 
The Game) 
The Outlaw Josey Wales) 
The Hateful Eight) 
Ferris Bueller's Day Off) 
The Fighter) 
About Time) 
The Girl with the Dragon Tattoo) 


Movies with IMDB rating (7.9,):
Mystic River) 
Nightcrawler) 
Moon) 
Star Trek) 
The Artist) 
I, Daniel Blake) 
Captain Fantastic) 
Marriage Story) 
The Irishman) 
Jab We Met) 
Hunt for the Wilderpeople) 
Boogie Nights) 
District 9) 
Thor: Ragnarok) 


Movies with IMDB rating (8.0,):
Sling Blade) 
Casino Royale) 
Rosemary's Baby) 
Cat on a Hot Tin Roof) 
The Help) 
Her) 
The King's Speech) 
Dallas Buyers Club) 
The Pursuit of Happyness) 
Kill Bill: Vol. 2) 
Doctor Zhivago) 
The Perks of Being a Wallflower) 
Fiddler on the Roof) 
Short Term 12) 
Jaws) 
Dances with Wolves) 
Dev.D) 
Magnolia) 
Kal Ho Naa Ho) 
Rain Man) 
Do the Right Thing) 
Vizontele) 


Movies with IMDB rating (8.1,):
PK) 
Cool Hand Luke) 
Dil Chahta Hai) 
Barfi!) 
Haider) 
Kahaani) 
Catch Me If You Can) 
Pink) 
Trainspotting) 
Gran Torino) 
Zindagi Na Milegi Dobara) 
Platoon) 
Rush) 
Spotlight) 
Hachi: A Dog's Tale) 
Kill Bill: Vol. 1) 
Million Dollar Baby) 
Room) 
A Wednesday) 
Rocky) 
Into the Wild) 


Movies with IMDB rating (8.2,):
Pan's Labyrinth) 
Udaan) 
There Will Be Blood) 
Indiana Jones and the Last Crusade) 
Klaus) 
Andaz Apna Apna) 
Queen) 
Drishyam) 
Monty Python and the Holy Grail) 
Lock, Stock and Two Smoking Barrels) 
Paan Singh Tomar) 
Shutter Island) 
Raging Bull) 
Rang De Basanti) 
V for Vendetta) 


Movies with IMDB rating (8.3,):
Inglourious Basterds) 
Andhadhun) 
A Clockwork Orange) 
American Beauty) 


Movies with IMDB rating (8.4,):
The Lives of Others) 
Spider-Man: Into the Spider-Verse) 
3 Idiots) 
Taare Zameen Par) 
Django Unchained) 
Dangal) 
Avengers: Infinity War) 
Once Upon a Time in America) 


Movies with IMDB rating (8.5,):
American History X) 
The Pianist) 
The Intouchables) 
The Departed) 
Once Upon a Time in the West) 


Movies with IMDB rating (8.7,):
The Lord of the Rings: The Two Towers) 
The Matrix) 


Movies with IMDB rating (8.8,):
Inception) 


Movies with IMDB rating (8.9,):
Schindler's List) 
Pulp Fiction) 
The Lord of the Rings: The Return of the King)


print("If you don't have particular preferences for any of those questions, please type 'skip'")
user_type = input("The type: Movie or TV Show: ")
user_dir = input("Preferred director's name: ")
user_country = input("Country: ")
user_year = input("The interval of years(e.g. 2010-2022): ")
user_duration = input("The interval of duration in minutes/seasons: ")

If you don't have particular preferences for any of those questions, please type 'skip'
The type: Movie or TV Show: Movie
Preferred director's name: David Fincher
Country: USA
The interval of years(e.g. 2010-2022): 2011-2020
The interval of duration in minutes/seasons: 60-80


user_pref_list = [user_type, user_dir, user_country, user_year, user_duration] #creates a list of all the user preferences
user_pref_list_valid = [i for i in user_pref_list if i != "skip"] #filters the list so that no "skip" value remains
length  = len(user_pref_list_valid) #calculates how many variables are stored in the list
percentage_for_1 = 100/length #calculates how much is the contribution of each inputted preference
df["percentage"] = 0 #creates a new column in our dataframe, 
#which will indicate the percentage of similarity of the exact movie to the user's search
if user_type != "skip": 
    type_matches = df["type"] == user_type #sets a condition for our later searching process
    if any(type_matches): #if the user's prefered type is found, the percentage is incremented by percentage_for_1
        df.loc[type_matches, "percentage"] += percentage_for_1
        
if user_dir != "skip":
    type_matches = df["director"] == user_dir
    if any(type_matches):
        df.loc[type_matches, "percentage"] += percentage_for_1
    
if user_country != "skip":
    type_matches = df["country"] == user_country
    if any(type_matches):
        df.loc[type_matches, "percentage"] += percentage_for_1
        
#The same thing is done as in the first if else block    

if user_year != "skip":
    #the variable user_year contains an interval where the minimum and maximum years are separated by '-'
    user_year = user_year.split("-") #splits the variable user_year to obtain a list of 2 elements
    min_year = int(user_year[0]) #first element is the starting point of the interval(minimum)
    max_year = int(user_year[1]) #second element is the ending point of the interval(maximum)

    year_matches = (df["release_year"] >= min_year) & (df["release_year"] <= max_year)
    if any(year_matches):
        df.loc[year_matches, "percentage"] += percentage_for_1
        
if user_duration != "skip":
    user_duration = user_duration.split("-")
    min_dur = int(user_duration[0])
    max_dur = int(user_duration[1])
    type_matches = (df["Number duration"] >= min_dur) & (df["Number duration"] <= max_dur)
    if any(type_matches):
        df.loc[type_matches, "percentage"] += percentage_for_1
#The same is done with the duration which is also given by the interval
df_search = df.sort_values(by='percentage', ascending = False) #creates a new Data Frame, sorted with respect to Percentage


df_subset = df_search[0:10] #subsets the first 10 rows of the sorted dataframe
for i in df_subset["title"]:
    print("The movie", i, "corresponds to your search by", df_subset["percentage"][df_subset["title"] == i].values[0], "%")
#Prints out the titles of 10 Movies/TV Shows that are more likely to correspond to the user's search

The movie Natalia Valdebenito: Gritona corresponds to your search by 60 %
The movie Happy Anniversary corresponds to your search by 60 %
The movie Aram, Aram corresponds to your search by 60 %
The movie Little Singham in London corresponds to your search by 60 %
The movie French Dirty corresponds to your search by 60 %
The movie The Delivery Boy corresponds to your search by 60 %
The movie Wedy Atkalam corresponds to your search by 60 %
The movie Dr Jason Leong Hashtag Blessed corresponds to your search by 60 %
The movie The Meaning of Monty Python corresponds to your search by 60 %
The movie Little Singham Bandarpur Mein Hu Ha Hu corresponds to your search by 60 %

	release_year
count	8807.000000
mean	2014.180198
std	8.819312
min	1925.000000
25%	2013.000000
50%	2017.000000
75%	2019.000000
max	2021.000000

	show_id	type	title	director	cast	country	date_added	release_year	rating	duration	listed_in	description
0	s1	Movie	Dick Johnson Is Dead	Kirsten Johnson	Unknown	United States	September 25, 2021	2020	PG-13	90 min	Documentaries	As her father nears the end of his life, filmm...
1	s2	TV Show	Blood & Water	Unknown	Ama Qamata, Khosi Ngema, Gail Mabalane, Thaban...	South Africa	September 24, 2021	2021	TV-MA	2 Seasons	International TV Shows, TV Dramas, TV Mysteries	After crossing paths at a party, a Cape Town t...
2	s3	TV Show	Ganglands	Julien Leclercq	Sami Bouajila, Tracy Gotoas, Samuel Jouy, Nabi...	MISSING	September 24, 2021	2021	TV-MA	1 Season	Crime TV Shows, International TV Shows, TV Act...	To protect his family from a powerful drug lor...
3	s4	TV Show	Jailbirds New Orleans	Unknown	Unknown	MISSING	September 24, 2021	2021	TV-MA	1 Season	Docuseries, Reality TV	Feuds, flirtations and toilet talk go down amo...
4	s5	TV Show	Kota Factory	Unknown	Mayur More, Jitendra Kumar, Ranjan Raj, Alam K...	India	September 24, 2021	2021	TV-MA	2 Seasons	International TV Shows, Romantic TV Shows, TV ...	In a city of coaching centers known to train I...
...	...	...	...	...	...	...	...	...	...	...	...	...
8802	s8803	Movie	Zodiac	David Fincher	Mark Ruffalo, Jake Gyllenhaal, Robert Downey J...	United States	November 20, 2019	2007	R	158 min	Cult Movies, Dramas, Thrillers	A political cartoonist, a crime reporter and a...
8803	s8804	TV Show	Zombie Dumb	Unknown	Unknown	MISSING	July 1, 2019	2018	TV-Y7	2 Seasons	Kids' TV, Korean TV Shows, TV Comedies	While living alone in a spooky town, a young g...
8804	s8805	Movie	Zombieland	Ruben Fleischer	Jesse Eisenberg, Woody Harrelson, Emma Stone, ...	United States	November 1, 2019	2009	R	88 min	Comedies, Horror Movies	Looking to survive in a world taken over by zo...
8805	s8806	Movie	Zoom	Peter Hewitt	Tim Allen, Courteney Cox, Chevy Chase, Kate Ma...	United States	January 11, 2020	2006	PG	88 min	Children & Family Movies, Comedies	Dragged from civilian life, a former superhero...
8806	s8807	Movie	Zubaan	Mozez Singh	Vicky Kaushal, Sarah-Jane Dias, Raaghav Chanan...	India	March 2, 2019	2015	TV-14	111 min	Dramas, International Movies, Music & Musicals	A scrappy but poor boy worms his way into a ty...

	IMDB_Rating	Meta_score	No_of_Votes
count	1000.000000	843.000000	1.000000e+03
mean	7.949300	77.971530	2.736929e+05
std	0.275491	12.376099	3.273727e+05
min	7.600000	28.000000	2.508800e+04
25%	7.700000	70.000000	5.552625e+04
50%	7.900000	79.000000	1.385485e+05
75%	8.100000	87.000000	3.741612e+05
max	9.300000	100.000000	2.343110e+06

Netflix Culture¶

Identifying Trends and Patterns in TV Shows and Movies¶

Introduction¶

The aim of our project¶

Data Cleaning¶

Getting basic information about dataset¶

Working with duration column and splitting it into 2 columns¶

Number of TV Shows and Movies¶

Years when the highest/lowest number of movies/TV shows available on Netflix were produced.¶

Rating System¶

Wordcloud of movie titles¶

Getting Top directors (w/ >= 10 movies)¶

Duration distribution¶

Average movie duration over time¶

Sentiment Analysis¶

Movies distribution among countries¶

New Dataset - IMDB TOP 1000¶

Basic information about the Dataset¶

Finding correlation between MetaScore and IMDB Rating¶

Correlation between Number of Votes and IMDB Rating¶

Genre distribution (in netflix movies that are in IMDB top 1000 movies list)¶

Top 10 Actors (in netflix movies that are in IMDB top 1000 movies list)¶

WordCloud of Actors' names¶

Collaborations between Directors and actors.¶

Grouping the movies based on their IMDB Rating¶

Movie Search System¶

Conclusion¶